SegmentGroup* SegmentCandidateFinder::initializeExprGroup(Expr* expr) {
  SegmentedGroup* expr_group = nullptr;
  if(expr2group.count(expr)) {
    expr_group = expr2group.at(expr);
  } else {
    expr_group = segmented_fusion_->newGroup(expr);
    expr2group.insert(std::make_pair(expr, expr_group));
  }

  for (auto inp : expr->inputs()) {
    if (input2group_.count(inp)) {
      expr_group->input_vals.push_back(inp);
      auto aux_group = input2group_.at(inp);
      auto new_edge = segmented_fusion_->newEdge(aux_group, expr_group, inp);
      expr_group->producer_edges.push_back(new_edge);
      aux_group->consumer_edges.push_back(new_edge);
      continue;
    }

    // Could be something like a constant scalar, definition is nullptr, but
    // isn't an "input" to the fusion. At least not one provided by an
    // external source.
    if (inp->definition() == nullptr) {
      continue;
    }

    auto def_group = expr2group.at(inp->definition());
    auto new_edge = segmented_fusion_->newEdge(def_group, expr_group, inp);
    expr_group->producer_edges.push_back(new_edge);
    def_group->consumer_edges.push_back(new_edge);
  }
  for (auto out : expr->outputs()) {
    if (out->isFusionOutput()) {
      expr_group->output_vals.push_back(out);
    }
  }
}

for (Val* output : fusion->outputs()) {
  if (output->isA<TensorView>()) {
    auto output_tv = output->as<TensorView>();
    const auto& [sizes, strides] = inferShapeOfOutput(output_tv, expr_eval);
    const auto dtype = (output_tv->dtype() == DataType::Index)
        ? data_type_to_aten(arg_index_type)
        : data_type_to_aten(output_tv->dtype());
    output_tensor_proxies.pushTensorProxy(sizes, strides, dtype);
  } else if (output->isScalar()) {
    switch (std::get<PrimDataType>(output->dtype().type)) {
      case DataType::Int:
      case DataType::Int32:
        output_tensor_proxies.push(PolymorphicValue(0LL));
        break;
      case DataType::Double:
      case DataType::Float:
        output_tensor_proxies.push(PolymorphicValue(0.0));
        break;
      case DataType::Bool:
        output_tensor_proxies.push(PolymorphicValue(false));
        break;
      default:
        NVF_ERROR("Output type not supported: ", output->toString());
    }
  } else {
    NVF_ERROR("Output type not supported: ", output->toString());
  }

scheduler_debug_utils::canScheduleMessage(
    "***Rejected*** scheduler ",
    scheduler_type,
    " cannot accept scalar outputs");
return false;